package PenTest.Soluation8;

import java.util.*;


/*
    题目： 添加括号
    1. 从后往前开始遍历， count 每到3 就添加一个
    2. 最后逆置字符串即可

 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();

        String str = String.valueOf(N);
        int  len = str.length();

        // 存储结果
        StringBuilder ret = new StringBuilder();

        int count = 0;
        for (int i = len - 1; i >= 0 ; i--) {
            count++;
            char ch = str.charAt(i);


            // 进行连接
            ret.append(ch);

            // 每走三步，就开始添加
            if (count == 3) {
                ret.append(",");
                count = 0;
            }

        }


        // 去掉最后一个是',' 
        if (ret.charAt(ret.length() - 1) == ',') {
            ret.deleteCharAt(ret.length() - 1);
        }

        // 反转输出
        System.out.println(ret.reverse().toString());


    }
}



/*
 题目： 青蛙跳台阶
  1. 等效于斐波那契数列问题
  2. 进行状态转移方程
  3. 考虑特殊情况
 */


 class Main1 {
    public static void main(String[] args) {
        // 输入
        Scanner in = new Scanner(System.in);
        int len = in.nextInt();

        // 特殊情况处理
        if(len ==0) {
            System.out.println(0);
            return;
        }

        // 进行 动态转移方程
        int[] dp = new int[len+1];
        dp[0]= 1;
        dp[1] = 1;


        // 进行状态转移
        for(int i = 2 ; i < len+1; i++) {

            dp[i] = dp[i-1] + dp[i-2];
        }

        // 开始输出
        System.out.println(dp[len]);

    }
}



/*
 题目： 扑克牌顺子
  1. 利用一个哈希数组来统计
  2. 除了之外有重复的就返回 false
  3. 数字和数字之间大小 <= 0 的个数，我们就说能出现连续的数字

 */



 class Solution {


    public boolean IsContinuous (int[] numbers) {
        // 记录数字大小
        int[] hash = new int[14];

        int min = 13;
        // 开始记录
        for(int i =0; i < 5; i++) {
            int num = numbers[i];

            // 记录
            hash[num]++;

            if(num != 0 &&  hash[num] > 1) {
                return false ;
            }

            // 并取出其中的除0外的最小值
            if(num != 0  ) {
                min = Math.min(min, num);
            }
        }


        int flg =  0;
        for(int i = min  ;i < 14 &&  i <= min + 4 ; i++) {
            if(hash[i] == 0) {
                flg++;
            }
        }

        return flg <= hash[0] ? true : false ;
    }
}



/*
 题目： 腐烂的苹果
 */




 class Solution1 {



    public int rotApple (ArrayList<ArrayList<Integer>> grid) {

        // 确定方位
        int[] dx = {0, 0, -1, 1};
        int[] dy = {-1, 1, 0, 0};

        //长度
        int row = grid.size();
        int col = grid.get(0).size();

        // 用于标记该苹果是否腐烂
        boolean[][] path = new boolean[row][col];

        // 队列存储腐烂苹果的下标
        Queue<int[]> queue = new LinkedList<>();

        // 开始遍历
        for (int i = 0; i < row ; i++) {
            for (int j = 0; j < col ; j++) {
                // 得到该数字
                int num = grid.get(i).get(j);
                // 存储腐烂苹果的下标
                if (num == 2) {
                    queue.add(new int[] {i, j});
                }
            }
        }

        // 存储腐烂的结果
        int ret = 0;

        // 外层代表原有的腐烂的苹果
        while (!queue.isEmpty()) {
            int sz = queue.size();

            // 进入内层中腐烂的苹果
            while (sz-- != 0) {
                // 弹出队列队顶元素
                int[] index = queue.poll();
                int i = index[0];
                int j = index[1];

                // 进行四周遍历和腐烂
                for (int k = 0 ; k < 4 ; k++) {
                    int x =  i + dx[k];
                    int y = j + dy[k];

                    // 查找该位置是否 1 并且是否腐烂过
                    if (x >= 0  && x < row && y >= 0 && y < col  &&
                            grid.get(x).get(y) == 1 && !path[x][y]) {
                        // 把该位置置为 true
                        path[x][y]= true;
                        //  并加入该位置
                        queue.add(new int[]{x,y});
                    }


                }

            }

            // 记录需要腐烂的时间
            ret++;
        }

        // 遍历是否还有好的苹果
        for(int i =0; i < row ; i++) {
            for(int j =0 ; j < col ; j++) {
                if(grid.get(i).get(j) == 1 && !path[i][j]) {
                    return -1;
                }
            }
        }

        return ret-1;
    }
}